_ENV["图色_多点找色"] = function(x1 , y1 , x2 , y2 , color , sim , 方向 , 点击)
	_ENV["坐标X"] , _ENV["坐标Y"] = findMultiColor(x1 , y1 , x2 , y2 , color[1] , color[2] , 方向 , sim)
	print(_ENV["坐标X"] , _ENV["坐标Y"])
	if _ENV["坐标X"] > 1 then
		if 点击 then
			_ENV["鼠标_随机点击"](_ENV["坐标X"] , _ENV["坐标Y"] , 800 , 1200)
		end
		return true
	end
	return false
end
_ENV["图色_找色"] = function(x1 , y1 , x2 , y2 , color , 方向 , 精度)
	local intX = 0
	local intY = 0
	local index = - 1
	index , intX , intY = findColor(x1 , y1 , x2 , y2 , color , 方向 , 精度)
	--print(index,intX,intY)
	if intX > 1 then
		return true
	end
	return false
end
_ENV["图色_多点找色Ex"] = function(颜色数组 , sim , 方向 , 偏移X , 偏移Y , 持续时间 , 点击 , 延迟)
	local 偏移X = 偏移X or 0
	local 偏移Y = 偏移Y or 0
	local 持续时间 = 持续时间 or 1
	for i = 1 , 持续时间 do
		--print(颜色数组[1], 颜色数组[2], 颜色数组[3], 颜色数组[4])
		_ENV["坐标X"] , _ENV["坐标Y"] = findMultiColor(颜色数组[1] , 颜色数组[2] , 颜色数组[3] , 颜色数组[4] , 颜色数组[5] , 颜色数组[6] , 方向 , sim)
		if 1 < _ENV["坐标X"] then
			if 点击 then
				_ENV["鼠标_随机点击"](_ENV["坐标X"] + 偏移X , _ENV["坐标Y"] + 偏移Y , 1000 , 1005)
			end

			return true
		elseif 持续时间 == i then
			--print("没有找到")
			
			return false
		end
		
		if 延迟 == nil or 延迟 == "" then
			print("延迟为空####################################")
			延迟 = 500
		end
		_ENV["延迟"](延迟)
	end
	print("没有找到")
	return false
end
_ENV["图色_多点找色字Ex"] = function(颜色数组 , sim , 方向 , 偏移X , 偏移Y , 持续时间 , 点击 , 查询的字 , 延迟 )
	local 偏移X = 偏移X or 0
	local 偏移Y = 偏移Y or 0
	local 持续时间 = 持续时间 or 1
	for i = 1 , 持续时间 do
		print(颜色数组[1] , 颜色数组[2] , 颜色数组[3] , 颜色数组[4])
		_ENV["坐标X"] , _ENV["坐标Y"] = findMultiColor(颜色数组[1] , 颜色数组[2] , 颜色数组[3] , 颜色数组[4] , 颜色数组[5] , 颜色数组[6] , 方向 , sim)
		if 1 < _ENV["坐标X"] then
			if 点击 then
				_ENV["鼠标_随机点击"](_ENV["坐标X"] + 偏移X , _ENV["坐标Y"] + 偏移Y , 100 , 400)
			end
			--print("找到")
			
			return true
		elseif 持续时间 == i then
			--print("没有找到")
			
			return false
		end
		
		if 延迟 == nil or 延迟 == "" then
			延迟 = 50
		end
		_ENV["延迟"](延迟)
	end
	--print("没有找到")
	
	if _ENV["文字寻找E"]({颜色数组[1] , 颜色数组[2] , 颜色数组[3] , 颜色数组[4] } , 3 , 查询的字 , 点击 ) then
		return true
	end
	return false
end
function 找色_连续找色点击(颜色数组1 , 颜色数组2 , 颜色数组2 , 颜色数组3 , 颜色数组3 , 颜色数组6)
	if 颜色数组1~= nil then
		_ENV["图色_多点找色Ex"](颜色数组1 , 0.9 , 0 , 0 , 0 , 200 , true )
	end
	if 颜色数组2~= nil then
		_ENV["图色_多点找色Ex"](颜色数组2 , 0.9 , 0 , 0 , 0 , 200 , true )
	end
	if 颜色数组3~= nil then
		_ENV["图色_多点找色Ex"](颜色数组3 , 0.9 , 0 , 0 , 0 , 200 , true )
	end
	if 颜色数组4~= nil then
		_ENV["图色_多点找色Ex"](颜色数组4 , 0.9 , 0 , 0 , 0 , 200 , true )
	end
	if 颜色数组5~= nil then
		_ENV["图色_多点找色Ex"](颜色数组5 , 0.9 , 0 , 0 , 0 , 200 , true )
	end
	if 颜色数组6~= nil then
		_ENV["图色_多点找色Ex"](颜色数组6 , 0.9 , 0 , 0 , 0 , 200 , true )
	end
	
end
function 多点找色_组 (颜色数多组 , sim , 方向 , 偏移X , 偏移Y , 持续时间 , 点击)
	local 偏移X = 偏移X or 0
	local 偏移Y = 偏移Y or 0
	local 持续时间 = 持续时间 or 1
	print(颜色数多组)
	print(#颜色数多组)
	for m = 1 , #颜色数多组 do
		local 颜色数组 = 颜色数多组[m]
		print(颜色数组)
		for i = 1 , 持续时间 do
			
			_ENV["坐标X"] , _ENV["坐标Y"] = findMultiColor(颜色数组[1] , 颜色数组[2] , 颜色数组[3] , 颜色数组[4] , 颜色数组[5] , 颜色数组[6] , 方向 , sim)
			if 1 < _ENV["坐标X"] then
				if 点击 then
					_ENV["鼠标_随机点击"](_ENV["坐标X"] + 偏移X , _ENV["坐标Y"] + 偏移Y , 800 , 1200)
				end
				--print("找到")
				return true
			elseif 持续时间 == i then
				--print("没有找到")
				
			end
			_ENV["延迟"](50)
		end
		
	end
	
	return false
end
function 缓存位图(缓存时间)
	local bmp = LuaEngine.snapShot(0 , 0 , 0 , 0)
	LuaEngine.setSnapCacheBitmap(bmp)
	--setSnapCacheTime(缓存时间)
end
function 缓存释放(缓存时间)
	LuaEngine.setSnapCacheBitmap(nil)
	LuaEngine.releaseBmp(bmp)
end
function 寻找文本1(str , 查找的文本组)
	
	if str == nil or str == "" then
		_ENV["调试输出"]("str为空" , true , 500)
		return false
	end
	local 关键字 = splitStr(查找的文本组 , "|")
	print(str , 关键字)
	for m = 1 , #关键字 do
		local index = string.find(str , 关键字[m] , 1)
		--print(index)
		if index then
			--print("找到字",关键字[m])
			return true
		else
			print("没有找到字" , 关键字[m])
			
		end
		
	end
	return false
end
function 寻找文本(str , 查找的文本组)
	-- 参数检查
	if type(str) ~= "string" or str == "" then
		local 调用堆栈 = debug.traceback("调用堆栈:", 2)
		_ENV["调试输出"]("错误: 输入字符串无效 - 类型: " .. type(str) .. ", 值: " .. tostring(str) .. ", 查找文本: " .. tostring(查找的文本组), true, 1000)
		_ENV["调试输出"]("调用堆栈: " .. 调用堆栈, true, 1000)
		return false
	end
	
	if type(查找的文本组) ~= "string" or 查找的文本组 == "" then
		local 调用堆栈 = debug.traceback("调用堆栈:", 2)
		_ENV["调试输出"]("错误: 查找文本组无效 - 类型: " .. type(查找的文本组) .. ", 值: " .. tostring(查找的文本组) .. ", 输入字符串: " .. tostring(str), true, 1000)
		_ENV["调试输出"]("调用堆栈: " .. 调用堆栈, true, 1000)
		return false
	end
	
	-- 分割关键字并处理空结果
	local 关键字 = splitStr(查找的文本组 , "|")
	if #关键字 == 0 then
		local 调用堆栈 = debug.traceback("调用堆栈:", 2)
		_ENV["调试输出"]("警告: 分割后无有效关键字 - 原始查找文本: " .. tostring(查找的文本组) .. ", 输入字符串: " .. tostring(str), true, 1000)
		_ENV["调试输出"]("调用堆栈: " .. 调用堆栈, true, 1000)
		return false
	end
	
	-- 调试输出原始字符串和关键字列表
	-- print("原始字符串:", str)
	-- print("关键字列表:", table.concat(关键字, ", "))
	
	-- 遍历关键字进行查找
	for m = 1 , #关键字 do
		local 原始关键字 = 关键字[m]
		local pattern = 原始关键字
		local index = string.find(str , pattern , 1 , true) -- 使用 plain 模式进行纯文本查找
		
		if index then
			--print("✓ 找到匹配关键字:", pattern)
			return true
		else
			-- print("✗ 未找到关键字:", pattern)
		end
	end
	
	return false
end
_ENV["图色_找图"] = function(x1 , y1 , x2 , y2 , 图片名 , sim , 持续时间 , 点击 , 资源文件)
	local 持续时间 = 持续时间 or 1
	for i = 1 , 持续时间 do
		_ENV["序号"] , _ENV["坐标X"] , _ENV["坐标Y"] = findImage(x1 , y1 , x2 , y2 , 图片名 , sim)
		if 1 < _ENV["坐标X"] and 1 < _ENV["坐标Y"] then
			if 点击 then
				_ENV["鼠标_随机点击"](_ENV["坐标X"] , _ENV["坐标Y"] , 800 , 1200)
			end
			--print("111111")
			
			return true
		elseif 持续时间 == i then
			--print("222222")
			return false
		end
		_ENV["延迟"](500)
	end
	print("222222")
	return false
	
	--[===[
	local index = -1
	local retList = nil
	index,retList=findPicFast(0,0,0,0,图片名,"101010",1,1)
	print(index,retList)
	
	]===]
	
end
_ENV["图色_多点找色ALL"] = function(颜色数组 , sim , 方向)
	local ret = findMultiColorAll(颜色数组[1] , 颜色数组[2] , 颜色数组[3] , 颜色数组[4] , 颜色数组[5] , 颜色数组[6] , 方向 , sim)
	return ret
end
_ENV["图色_多点比色"] = function(数组 , x , y , 点击)
	local r = cmpColorExT(数组)
	if r == 1 then
		if 点击 then
			_ENV["随机点击"](x , y , 800 , 1200)
		end
		return true
	end
	return false
end
_ENV["文字_神经网络找字"] = function(x1 , y1 , x2 , y2 , 字符串 , 隔离 , 比例 , 置信度 , 默认 , 倍率 , 角度 , 方向)
	local r = ocrEx(x1 , y1 , x2 , y2 , 隔离 , 比例 , 置信度 , 默认 , 倍率 , 角度 , 方向)
	
	if r ~= nil then
		for i = 1 , #r do
			print(r[i])
			local 寻找 = string.find(r[i].text , 字符串 , 1)
			if 寻找 == 1 then
				print("找到" .. r[i].text)
				print(r[i].r)
				local 宽度 = (r[i].r - r[i].l) / 2
				local 高度 = (r[i].b - r[i].t) / 2
				print(宽度 , 高度)
				local 中心X = r[i].l + 宽度
				local 中心Y = r[i].t + 高度
				print(中心X , 中心Y)
				_ENV["神经信息"] = {
					["字符串"] = r[i].text ,
					x1 = r[i].l ,
					y1 = r[i].t ,
					x2 = r[i].r ,
					y2 = r[i].b ,
					["中心X"] = 中心X ,
					["中心Y"] = 中心Y
				}
				return true
			else
				print(r[i].text .. "~=" .. 字符串)
			end
		end
	end
	return false
end
_ENV["文字_神经网络识字"] = function(x1 , y1 , x2 , y2 , 隔离 , 比例 , 置信度 , 默认 , 倍率 , 角度 , 方向)
	local r = ocrEx(x1 , y1 , x2 , y2 , 隔离 , 比例 , 置信度 , 默认 , 倍率 , 角度 , 方向)
	if r ~= nil then
		for i = 1 , #r do
			local 宽度 = (r[i].r - r[i].l) / 2
			local 高度 = (r[i].b - r[i].t) / 2
			local 中心X = r[i].l + 宽度
			local 中心Y = r[i].t + 高度
			_ENV["神经信息"] = {
				["文字"] = r[i].text ,
				x1 = r[i].l ,
				y1 = r[i].t ,
				x2 = r[i].r ,
				y2 = r[i].b ,
				["中心X"] = 中心X ,
				["中心Y"] = 中心Y
			}
			return true
		end
	end
	return false
end
_ENV["文字_区域找字"] = function(x1 , y1 , x2 , y2 , 文字 , 偏色 , 相似度 , 字库 , 点击)
	useDict(字库)
	
	local ret , x , y = findStr(x1 , y1 , x2 , y2 , 文字 , 偏色 , 相似度)
	
	if x ~= - 1 and y ~= - 1 then
		if 点击 then
			_ENV["鼠标_随机点击"](x , y , 800 , 1200)
		end
		_ENV["找字信息"] = {
			["索引"] = ret ,
			x = x ,
			y = y
		}
		
		--print("文字_找到")
		return true
	else
		--print("文字_没有")
		
		return false
	end
end
_ENV["文字_OCR识字"] = function(x1 , y1 , x2 , y2 , 偏色 , 相似度 , 字库)
	useDict(字库)
	local 识别结果 = ocr(x1 , y1 , x2 , y2 , 偏色 , 相似度)
	if 识别结果 == nil then
		识别结果 = ""
	end
	print(识别结果)
	return 识别结果
end
_ENV["文字_OCRJ识字"] = function(x1 , y1 , x2 , y2 , 偏色 , 相似度 , 字库)
	useDict(字库)
	local 识别结果 = ocrj(x1 , y1 , x2 , y2 , 偏色 , 相似度)
	if 识别结果 ~= nil then
		return 识别结果
	else
		return ""
	end
end
_ENV["鼠标_随机点击"] = function(x , y , time1 , time2)
	if x == nil or y == nil then
		_ENV["调试输出"]("鼠标点击空坐标" , true , 500)
		return false
	end
	time1=time1 or 0
	time2=time2 or 0
	local s = rnd(time1 , time2)
	local r = rnd( - 4 , 11)
	local r1 = rnd( - 4 , 11)
	
	tap(x + r , y + r1)
	sleep(s)
	-------------------------------------
	--[===[local r = rnd(-3, 10)
	local r1 = rnd(-3, 10)
	local s = rnd(time1, time2)
	
	
	
	touchDown(1,x + r, y + r1)
	sleep(300)
	touchUp(1)
	sleep(s)]===]
	
end
_ENV["鼠标_寻路点击"] = function(x , y)
	local s = rnd(500 , 800)
	tap(x , y)
	sleep(200)
	tap(x , y)
	sleep(s)
end
_ENV["鼠标_模拟滑动"] = function(x1 , y1 , x2 , y2 , time , 等待 , 次数)
	local 等待 = 等待 or 0
	local r = rnd(1 , 100)
	if 次数 == nil then
		次数 = 1
	end
	for i = 1 , 次数 do
		--print("i:",i)
		swipe(x1 , y1 , x2 , y2 , time + r)
		_ENV["延迟"](等待 + r)
	end
	
end
_ENV["鼠标_精准滑动"] = function(x1 , y1 , x2 , y2 , time , 等待)
	swipe(x1 , y1 , x2 , y2 , time)
	_ENV["延迟"](等待)
end
_ENV["触摸_捏合"] = function(x1 , y1 , x2 , y2 , 终点X , 终点Y , time)
	touchDown(1 , x1 , y1)
	touchDown(2 , x2 , y2)
	sleep(100)
	touchMove(1 , 终点X , 终点Y)
	
	touchMove(2 , 终点X , 终点Y)
	sleep(time)
	touchUp(1)
	touchUp(2)
end
_ENV["节点_节点查找"] = function(x1 , y1 , x2 , y2 , 节点数组 , 点击 , 延迟 , 点击方式)
	_ENV["节点信息"] = nodeLib.findOne(x1 , y1 , x2 , y2 , 节点数组 , false)
	if _ENV["节点信息"] ~= nil then
		--print(_ENV["节点信息"].text)
		if 点击 then
			--print("点击节点")
			_ENV["节点_节点点击"](_ENV["节点信息"] , 500 , 800 , 点击方式)
			sleep(延迟)
		end
		return true
	else
		return false
	end
end
_ENV["节点_节点点击"] = function(节点数组 , time1 , time2 , 点击方式)
	local r = rnd(0 , 10)
	local s = rnd(time1 , time2)
	nodeLib.click(节点数组 , 点击方式)
	sleep(s)
end
_ENV["文本_取左边"] = function(源文本 , 字符)
	local 位置 = utf8.inStr(0 , 源文本 , 字符)
	if 位置 == nil then
		return nil
	end
	local 截取长度 = 位置 - 1
	local str = utf8.mid(源文本 , 1 , 截取长度)
	return str
end
_ENV["文本_取右边"] = function(源文本 , 字符)
	local 自身长 = utf8.length(字符)
	local 位置 = utf8.inStr(0 , 源文本 , 字符)
	if 位置 == nil then
		return nil
	end
	local 总长度 = utf8.length(源文本)
	local 截取长度 = 总长度 - 位置
	local str = utf8.mid(源文本 , 位置 + 1 , 截取长度)
	return str
end
_ENV["文本_取中间"] = function(源文本 , 左边 , 右边)
	local 左边位置 = utf8.inStr(0 , 源文本 , 左边)
	local 自身长度 = string.len(左边)
	local 右边位置 = utf8.inStr(左边位置 , 源文本 , 右边)
	if 左边位置 <= 0 or 右边位置 <= 0 or 自身长度 <= 0 then
		return nil
	end
	if 左边位置 > 右边位置 then
		return nil
	end
	_ENV["长度"] = 右边位置 - 左边位置 - 自身长度
	local str = utf8.mid(源文本 , 左边位置 + 自身长度 , _ENV["长度"])
	return str
end
_ENV["文本_输入文本"] = function(文本 , x , y)
	_ENV["节点_节点查找"](0 , 0 , 0 , 0 , {
		class = "android.widget.EditText" ,
		package = "com.wemade.nightcrowsglobal"
	} , false , 100 , false)
	nodeLib.setText(_ENV["返回值"] , 文本)
	_ENV["节点_节点查找"](0 , 0 , 0 , 0 , _ENV["输入完成OK"] , true , 100 , false)
end
_ENV["文本_替换文本"] = function(源文件 , 替换1 , 换成1 , 替换2 , 换成2 , 替换3 , 换成3 , 替换4 , 换成4 , 替换5 , 换成5 , 替换6 , 换成6 , 替换7 , 换成7 , 替换8 , 换成8 , 替换9 , 换成9 , 替换10 , 换成10)
	if 源文件 == nil then
		return 源文件
	end
	--print(源文件)
	local ret = 源文件
	if 替换1 ~= nil then
		ret = string.gsub(ret , 替换1 , 换成1)
	else
		
		return ret
	end
	if 替换2 ~= nil then
		ret = string.gsub(ret , 替换2 , 换成2)
	else
		return ret
	end
	if 替换3 ~= nil then
		ret = string.gsub(ret , 替换3 , 换成3)
	else
		return ret
	end
	if 替换4 ~= nil then
		ret = string.gsub(ret , 替换4 , 换成4)
	else
		return ret
	end
	if 替换5 ~= nil then
		ret = string.gsub(ret , 替换5 , 换成5)
	else
		return ret
	end
	if 替换6 ~= nil then
		ret = string.gsub(ret , 替换6 , 换成6)
	else
		return ret
	end
	if 替换7 ~= nil then
		ret = string.gsub(ret , 替换7 , 换成7)
	else
		return ret
	end
	if 替换8 ~= nil then
		ret = string.gsub(ret , 替换8 , 换成8)
	else
		return ret
	end
	if 替换9 ~= nil then
		ret = string.gsub(ret , 替换9 , 换成9)
	else
		return ret
	end
	if 替换10 ~= nil then
		ret = string.gsub(ret , 替换10 , 换成10)
	else
		return ret
	end
	
	return ret
end
_ENV["文本_只取数字"] = function(源文本)
	if 源文本 == nil or 源文本 == "" then
		return ""
	end
	local pattern = "%d+" -- 匹配连续的数字
	for num in string.gmatch(源文本 , pattern) do
		--print(num)
		return num
	end
	
end
_ENV["游戏_输入文本"] = function(文本 , x , y)
	
	_ENV["鼠标_随机点击"](x , y , 800 , 1000)
	_ENV["节点_节点查找"](0 , 0 , 0 , 0 , {class = "android.widget.FrameLayout" , package = "com.wemade.nightcrowsglobal" , text = ""}
	, false , 100 , false)
	print(_ENV["节点信息"])
	nodeLib.setText(_ENV["节点信息"] , 文本 )
end
_ENV["文本_取随机字母"] = function(字符数)
	local 返回值 = ""
	for i = 1 , 字符数 do
		local 随机数 = rnd(1 , 24)
		if 随机数 == 1 then
			返回值 = 返回值 .. "a"
		elseif 随机数 == 2 then
			返回值 = 返回值 .. "b"
		elseif 随机数 == 3 then
			返回值 = 返回值 .. "c"
		elseif 随机数 == 3 then
			返回值 = 返回值 .. "c"
		elseif 随机数 == 4 then
			返回值 = 返回值 .. "d"
		elseif 随机数 == 5 then
			返回值 = 返回值 .. "e"
		elseif 随机数 == 6 then
			返回值 = 返回值 .. "f"
		elseif 随机数 == 7 then
			返回值 = 返回值 .. "g"
		elseif 随机数 == 8 then
			返回值 = 返回值 .. "h"
		elseif 随机数 == 9 then
			返回值 = 返回值 .. "c"
		elseif 随机数 == 10 then
			返回值 = 返回值 .. "d"
		elseif 随机数 == 11 then
			返回值 = 返回值 .. "k"
		elseif 随机数 == 12 then
			返回值 = 返回值 .. "g"
		elseif 随机数 == 13 then
			返回值 = 返回值 .. "p"
		elseif 随机数 == 14 then
			返回值 = 返回值 .. "o"
		elseif 随机数 == 15 then
			返回值 = 返回值 .. "o"
		elseif 随机数 == 16 then
			返回值 = 返回值 .. "p"
		elseif 随机数 == 17 then
			返回值 = 返回值 .. "q"
		elseif 随机数 == 18 then
			返回值 = 返回值 .. "r"
		elseif 随机数 == 19 then
			返回值 = 返回值 .. "s"
		elseif 随机数 == 20 then
			返回值 = 返回值 .. "t"
		elseif 随机数 == 21 then
			返回值 = 返回值 .. "u"
		elseif 随机数 == 22 then
			返回值 = 返回值 .. "v"
		elseif 随机数 == 23 then
			返回值 = 返回值 .. "w"
		elseif 随机数 == 24 then
			返回值 = 返回值 .. "x"
		elseif 随机数 == 25 then
			返回值 = 返回值 .. "y"
		elseif 随机数 == 26 then
			返回值 = 返回值 .. "z"
		end
	end
	return 返回值
end
_ENV["数学_计算距离"] = function(中心X , 中心Y , 当前坐标X , 当前坐标Y)
	local 距离 = math.sqrt(math.abs(当前坐标X - 中心X) ^ 2 + math.abs(当前坐标Y - 中心Y) ^ 2)
	return 距离
end
_ENV["数学_坐标转换"] = function(开发宽度 , 开发高度 , 点击坐标x , 点击坐标y)
	local 预点击x , 预点击y , w , h
	w , h = getDisplaySize()
	if 开发宽度 == w and 开发高度 == h then
		print("无需转换" , 点击坐标x , 点击坐标y)
		tap(点击坐标x , 点击坐标y)
		return
	end
	if 开发宽度 == w then
		预点击x = 点击坐标x
	end
	if 开发高度 == h then
		预点击y = 点击坐标y
	end
	if 开发宽度 > w then
		预点击x = 点击坐标x / (开发宽度 / w)
	else
		预点击x = w / 开发宽度 * 点击坐标x
	end
	if 开发高度 > h then
		预点击y = 点击坐标y / (开发高度 / h)
	else
		预点击y = h / 开发高度 * 点击坐标y
	end
	tap(预点击x , 预点击y)
	return
end
_ENV["数组_寻找文本"] = function(数组 , 字符串)
	for i = 1 , #数组 do
		if string.find(数组[i] , 字符串 , 1) ~= nil then
			return true
		end
	end
	return false
end
_ENV["文件_保存完成时间"] = function(任务名称)
	local time = tostring(os.time())
	if 任务名称 == "四角色繁荣之地" then
		local now = os.time()
		local date = os.date("*t" , now)
		date.hour = tonumber(_ENV["配置信息"]["繁荣之地进入时间"])
		date.min = 0
		date.sec = 0
		local time_at_1am = os.time(date)
		time = tostring(time_at_1am)
		print(time)
		
	end
	
	if writeFile(_ENV["SD卡路径"] .. 任务名称 .. ".txt" , time , false) then
		_ENV["调试输出"]("完成记录保存成功:", 任务名称)
	else
		_ENV["调试输出"]("完成记录保存失败" , true)
	end
end
_ENV["文件_读取完成时间"] = function(任务名称)
	local ret = readFile(_ENV["SD卡路径"] .. 任务名称 .. ".txt")
	return ret
end
_ENV["文件_0时数据保存记录"] = function(任务名称 , 黑铁数量 , 真气数量 , 金币数量)
	if 任务名称 == nil or 黑铁数量 == nil or 真气数量 == nil then
		_ENV["调试输出"]("记录传入错误" , true)
		return
	end
	_ENV["0时黑铁"] = 黑铁数量
	_ENV["0时真气"] = 真气数量
	_ENV["0时金币"] = 金币数量
	local time = os.time()
	local 当前_日 = tostring(os.date("%d" , time))
	print("111" , 当前_日)
	local 内容 = 当前_日.."|".._ENV["0时黑铁"].."|".._ENV["0时真气"].."|".._ENV["0时金币"]
	if writeFile(_ENV["SD卡路径"] .. 任务名称 .. ".txt" , 内容 , false) then
	else
		_ENV["调试输出"]("记录保存失败" , true)
	end
end
_ENV["文件_0时数据读取记录"] = function(任务名称)
	local ret = readFile(_ENV["SD卡路径"] .. 任务名称 .. ".txt")
	print(ret)
	local 当前_日 = tostring(os.date("%d" , time))
	local 记录数据 = splitStr(ret , "|")
	print(当前_日 , 记录数据[1])
	if 记录数据[1] ~= 当前_日 then
		_ENV["调试输出"]("非今日数据--刷新数据" , true)
		--_ENV["功能_读取人物信息"](false, true)
		--_ENV["文件_0时数据保存记录"]("今日0点黑铁数量",_ENV["黑铁数量"],_ENV["真气数量"],_ENV["金币数量"] )
		return false
	end
	_ENV["0时黑铁"] = 记录数据 [2]
	print(_ENV["0时黑铁"])
	_ENV["0时真气"] = 记录数据 [3]
	print(_ENV["0时真气"] )
	_ENV["0时金币"] = 记录数据 [4]
	print(_ENV["0时金币"])
	return true
	
end
_ENV["文件_保存记录"] = function(任务名称 , 记录内容)
	if 任务名称 == nil or 记录内容 == nil then
		_ENV["调试输出"]("记录传入错误" , true)
	end
	local time = tostring(os.time())
	local 内容 = jsonLib.encode({
		["记录内容"] = 记录内容 ,
		["记录时间"] = time
	})
	if writeFile(_ENV["SD卡路径"] .. 任务名称 .. ".txt" , 内容 , false) then
	else
		_ENV["调试输出"]("记录保存失败" , true)
	end
end
_ENV["文件_读取记录"] = function(任务名称)
	_ENV["读取内容"] = {}
	local ret = readFile(_ENV["SD卡路径"] .. 任务名称 .. ".txt")
	if ret ~= "" then
		_ENV["读取内容"] = jsonLib.decode(ret)
		return _ENV["读取内容"]
	end
	return false
end
_ENV["文件_保存信息"] = function(任务名称 , 记录内容)
	if not 任务名称 or not 记录内容 then
		_ENV["调试输出"]("记录传入错误" , true)
		return
	end
	
	local 完整记录 = tostring(记录内容..os.date("%Y-%m-%d %H:%M:%S")).. "\n"
	print(完整记录)
	if writeFile(_ENV["SD卡路径"] .. 任务名称 .. ".txt" , 完整记录 , true) then
	else
		_ENV["调试输出"]("完成记录保存失败" , true)
	end
	
end
_ENV["文件_保存装备信息"] = function(装备名称 , 装备品质 , 装备阶级 , 记录时间)
	if 装备名称 == nil or 装备品质 == nil then
		_ENV["调试输出"]("记录传入错误" , true)
	end
	local 内容 = jsonLib.encode({
		["装备品质"] = 装备品质 ,
		["装备阶级"] = 装备阶级 ,
		["记录时间"] = tostring(记录时间)
	})
	if writeFile(_ENV["SD卡路径"] .. 装备名称 .. ".txt" , 内容 , false) then
	else
		_ENV["调试输出"]("记录保存失败" , true)
	end
end
_ENV["时间_是否时间范围"] = function(时间1 , 时间2)
	local 起始时间 = tonumber(时间1)
	_ENV["结束时间"] = tonumber(时间2)
	local 当前_时 = tonumber(os.date("%H" , os.time()))
	if 起始时间 > _ENV["结束时间"] then
		if 起始时间 <= 当前_时 or 当前_时 < _ENV["结束时间"] then
			return true
		else
			return false
		end
	end
	if 起始时间 < _ENV["结束时间"] then
		if 起始时间 <= 当前_时 and 当前_时 < _ENV["结束时间"] then
			return true
		else
			return false
		end
	end
end
_ENV["文件_任务是否完成"] = function(任务 , 刷新时间)
	local 刷新时间 = _ENV["到整数"](刷新时间)
	local 记录时间 = math.tointeger(_ENV["文件_读取完成时间"](任务))
	-- 将时间戳转换为日期时间
	local date_time = os.date("%Y-%m-%d %H:%M:%S" , 记录时间)
	-- 输出结果
	print(任务.."记录时间" , date_time)
	if 记录时间 == nil then
		return false
	end
	local 记录_日 = math.tointeger(os.date("%d" , 记录时间))
	local 记录_时 = math.tointeger(os.date("%H" , 记录时间))
	local 当前时间 = os.time()
	local 当前_日 = math.tointeger(os.date("%d" , 当前时间))
	local 当前_时 = math.tointeger(os.date("%H" , 当前时间))
	print(刷新时间 , 记录_日 , 记录_时)
	--print(刷新时间,当前_日,当前_时)
	if 记录_日 == nil or 当前_日 == nil or 记录_时 == nil or 当前_时 == nil then
		_ENV["调试输出"](任务 .. "时间获取失败-未完成" , true)
		return false
	end
	if 当前_日 == 记录_日 then
		if 刷新时间 <= 记录_时 then
			return true--做了
		elseif 刷新时间 <= math.tointeger(当前_时) then
			return false--没做
		else
			return true
		end
	end
	if 记录_日 < 当前_日 then
		local 间隔天数 = 当前_日 - 记录_日
		if 间隔天数 >= 1 then
			if 刷新时间 <= 当前_时 then
				return false
			else
				return true
			end
		else
			return false
		end
	end
	return false
end
_ENV["文件_取间隔时间分钟"] = function(任务名称)
	
	local 当前时间 = os.time()
	local 记录时间 = _ENV["文件_读取完成时间"](任务名称)
	print(记录时间)
	if 记录时间 == "" then
		记录时间 = 631126860
	end
	return (当前时间 - 记录时间) / 60
end
_ENV["文件_取间隔时间小时"] = function(任务名称)
	local 当前时间 = os.time()
	local 记录时间 = _ENV["文件_读取完成时间"](任务名称)
	--print("读取完成时间"..任务名称..记录时间)
	if 记录时间 == "" then
		记录时间 = 631126860
	end
	
	-- 确保记录时间和当前时间都是有效的数字
	local 记录时间数字 = tonumber(记录时间)
	local 当前时间数字 = tonumber(当前时间)
	
	-- 检查转换结果，避免 nil 参与运算
	if 记录时间数字 and 当前时间数字 then
		-- 计算小时差（除以3600将秒转换为小时）
		return (当前时间数字 - 记录时间数字) / 3600
	else
		-- 处理转换失败的情况
		print("[错误] 时间转换失败，无法计算小时差")
		return 0 -- 或返回 nil/其他默认值，根据业务需求决定
	end
	
end
_ENV["文件_任务间隔小时执行"] = function(任务名称 , 间隔时间)
	
	--print(_ENV["文件_取间隔时间小时"](任务名称))
	--print(间隔时间)
	if tonumber(_ENV["文件_取间隔时间小时"](任务名称)) > tonumber(间隔时间) then
		return true
	else
		return false
	end
end
_ENV["验证_心跳回调"] = function(msg)
	if msg.code == 1 then
		print("心跳成功")
	elseif msg.code == - 5 then
		print("请重新登录,一般是卡密被禁用,删除,设备被解绑!")
		--exitScript()
	elseif msg.code == - 8 then
		print("卡密到期")
		--exitScript()
	elseif msg.code == - 9999 then
		print("心跳失败,网络错误!")
	elseif msg.code == - 6666 then
		print("有人尝试破解卡密系统!" , msg.cdkey)
	else
		print("未知错误!" , msg.msg)
	end
end
_ENV["设备_取内网IP"] = function()
	local 设备信息 = exec("ip add show wlan0")
	return _ENV["文本_取中间"](设备信息 , "inet " , "/")
end
_ENV["客户_提交数据"] = function(内容)
	while true do
		for i = 100 , 1 , - 1 do
			
			local ret , code = httpPost(_ENV["IP地址"] .. ":6688" , "当前要求=" .. jsonLib.encode(内容) , 30)
			
			print(code)
			if code == 200 and ret ~= "" and ret ~= "未知的要求" then
				
				writeFile(_ENV["SD卡路径"] .. "提取数据.txt" , ret , false)
				local 转换结果 = jsonLib.decode(ret)
				return 转换结果
			else
				_ENV["调试输出"]("提取配置失败" .. i , true , 1000)
			end
		end
		local 消息 = {
			["类型"] = "上传异常" ,
			["编号"] = _ENV["编号"] ,
			["异常状态"] = "提取配置失败"
		}
		- _ENV["客户_消息发送"](_ENV["服务器ID"] , 消息)
		_ENV["调试输出"]("提交数据失败" , true , 6000)
	end
end
_ENV["设备_改分辨率"] = function()
	while true do
		local dpi = getDisplayDpi()
		local w , h = getDisplaySize()
		if dpi ~= 320 or w ~= 720 or h ~= 1280 then
			print("修改分辨率")
			setDisplaySize(720 , 1280 , 320)
			_ENV["延迟"](3000)
		else
			print("分辨率没动")
			return true
		end
		_ENV["延迟"](1000)
	end
end
_ENV["读取配置"] = function()
	_ENV["配置信息"] = _ENV["客户_提交数据"]({
		["类型"] = "提取配置" ,
		["编号"] = _ENV["编号"]
	})
	_ENV["调试输出"](_ENV["配置信息"] , true , 1000)
end
_ENV["取表长度"] = function(t)
	local leng = 0
	for k , v in pairs(t) do
		leng = leng + 1
	end
	return leng
end
_ENV["调试输出"] = function(内容 , 显示 , 等待时间)
	local 等待时间 = 等待时间 or 0
	print(内容)
	if 显示 then
		toast(内容 , 503 , 23 , 12)
		
				--writeLog(内容)
		end
	sleep(等待时间)
	--_ENV["延迟"](等待时间)
end
_ENV["到整数"] = function(文本)
	--_ENV["调试输出"] ("到整数"..文本)
	
	文本 = _ENV["文本_只取数字"](文本)
	
	if 文本 == nil or 文本 == "" then
		return - 1
	end
	local a = tonumber(文本)
	if a == 0 then
		
		return - 1
	end
	
	local b , c = math.modf(a)
	if b == nil then
		return - 1
	else
		return b
	end
end
_ENV["到小数后一位"] = function(num_str)
	print(num_str)
	
	local integer_part , decimal_part = string.match(num_str , "([^.]+)%.?([^.]*)")
	
	-- 如果没有小数部分，直接返回原数字字符串
	if not decimal_part or decimal_part == "" then
		print(integer_part)
		return integer_part
	end
	
	-- 检查小数部分是否全为0
	local all_zero = true
	for i = 1 , #decimal_part do
		if string.sub(decimal_part , i , i) ~= '0' then
			all_zero = false
			break
		end
	end
	
	-- 如果小数部分全为0，返回整数部分
	if all_zero then
		print(integer_part)
		return integer_part
	else
		-- 否则保留第一位小数
		local first_digit = string.sub(decimal_part , 1 , 1)
		local result = integer_part .. "." .. first_digit
		print(result)
		return result
	end
end
_ENV["到文本"] = function(文本)
	if 文本 == nil then
		return ""
	end
	local a = tostring(文本)
	return a
end
_ENV["到数值"] = function(文本)
	local a = tonumber(文本)
	
	if a == nil then
		return 999999
	end
	return a
end
_ENV["延迟"] = function(毫秒)
	-- 检查毫秒参数是否为有效数字
	if 毫秒 == nil or type(毫秒) ~= "number" then
		--_ENV["调试输出"]("延迟函数参数错误，毫秒值为: " .. tostring(毫秒), true)
		return
	end
	
	--[===[	if _ENV["运行状态"] == "暂停运行" then
	while true do
	if _ENV["运行状态"] == "正常运行" then
	toast("恢复运行" , 580 , 680 , 10)
	break
	end
	if _ENV["当前任务"] == "重启脚本" then
	_ENV["调试输出"]("准备重启脚本" , true)
	restartScript()
	end
	toast("暂停运行中" , 580 , 680 , 10)
	sleep(2000)
	end
	elseif _ENV["当前任务"] == "重启脚本" then
	_ENV["调试输出"]("准备重启脚本" , true)
	restartScript()
	end]===]
	sleep(毫秒)
end
function 取余数(除数 , 被除数)
	local 余数 = math.fmod(除数 , 被除数)
	return 余数
	
end
setStopCallBack(function(err)
	setIme(false)
end)
_ENV["文字识别881"] = function(x1 , y1 , x2 , y2 , 类型 , 关键字组)
	
	if x1 == nil or y1 == nil or x2 == nil or y2 == nil then
		print(x1 , y1 , x2 , y2)
		print("文字识别--空坐标")
		
		return ""
	end
	
	local Bitmap = LuaEngine.snapShot(x1 , y1 , x2 , y2)
	--PaddleOcr.setDetUnclipRatio(2.0)
	local jsonstring = PaddleOcr.detectWithPadding(Bitmap , 100 , 0xff , 0xff , 0xff)
	--local jsonstring = PaddleOcr.detect(Bitmap) ----百度免费版本
	
	--print(jsonstring)
	if jsonstring ~= "" then
		local 转换结果 = jsonLib.decode(jsonstring)
		--print(转换结果)
		if 1 <= #转换结果 then
			if 关键字组 ~= nil then
				local 关键字 = splitStr(关键字组 , "|")
				for i = 1 , #转换结果 do
					for m = 1 , #关键字 do
						local ret = string.find(转换结果[i].label , 关键字[m] , 1)
						if ret ~= nil then
							Bitmap.recycle()
							LuaEngine.releaseBmp(bitmap)
							return 转换结果[i].label
						end
					end
				end
				Bitmap.recycle()
				LuaEngine.releaseBmp(bitmap)
				return ""
			else
				
				_ENV["坐标X"] = 转换结果[1].x
				_ENV["坐标Y"] = 转换结果[1].y
				--print(_ENV["坐标X"],_ENV["坐标Y"])
				Bitmap.recycle()
				return 转换结果[1].label
			end
		end
		Bitmap.recycle()
		LuaEngine.releaseBmp(bitmap)
		return ""
	end
	
	--Bitmap.recycle()
	return ""
end
_ENV["文字寻找E88"] = function(找色组 , 类型 , 关键字组 , 点击)
	--print(找色组, 类型, 关键字组,点击)
	if 找色组[1] == nil or 找色组[2] == nil or 找色组[3] == nil or 找色组[4] == nil then
		
		print("文字识别--空坐标")
		return false
	end
	--local 路径 = _ENV["OCR路径"] .. "/ocr.png"
	local Bitmap = LuaEngine.snapShot(找色组[1] , 找色组[2] , 找色组[3] , 找色组[4])
	local jsonstring = PaddleOcr.detect(Bitmap) ----百度免费版本
	--print("jsonstring")
	--print(jsonstring)
	
	if jsonstring ~= "" then
		local 转换结果 = jsonLib.decode(jsonstring)
		
		if 1 <= #转换结果 then
			if 关键字组 ~= nil then
				local 关键字 = splitStr(关键字组 , "|")
				for i = 1 , #转换结果 do
					--print(转换结果[i])
					for m = 1 , #关键字 do
						local ret = string.find(转换结果[i].label , 关键字[m] , 1)
						if ret ~= nil then
							--155,214,1336,895
							
							_ENV["坐标X"] = 转换结果[i].x + 找色组[1]
							_ENV["坐标Y"] = 转换结果[i].y + 找色组[2]
							--print(_ENV["坐标X"],_ENV["坐标Y"])
							if 点击 then
								_ENV["鼠标_随机点击"](_ENV["坐标X"] , _ENV["坐标Y"] , 800 , 1000)
							end
							return true
						end
					end
				end
				Bitmap.recycle()
				return false
			else
				Bitmap.recycle()
				--print(_ENV["坐标X"],_ENV["坐标Y"])
				return true
			end
		end
		Bitmap.recycle()
		return false
	end
	Bitmap.recycle()
	return false
end
_ENV["文字寻找88"] = function(x1 , y1 , x2 , y2 , 类型 , 文字 , 匹配 , 点击)
	
	local Bitmap = LuaEngine.snapShot(x1 , y1 , x2 , y2)
	local jsonstring = PaddleOcr.detect(Bitmap) ----百度免费版本
	if jsonstring ~= "" then
		local 转换结果 = jsonLib.decode(jsonstring)
		if 1 <= #转换结果 then
			local 文字数组 = splitStr(文字 , "|")
			if 匹配 == "模糊" then
				for i = 1 , #转换结果 do
					for g = 1 , #文字数组 do
						if string.find(转换结果[i].label , 文字数组[g] , 1) ~= nil then
							_ENV["坐标X"] = 转换结果[1].x + x1
							_ENV["坐标Y"] = 转换结果[1].y + y1
							if 点击 then
								_ENV["鼠标_随机点击"](_ENV["坐标X"] + 10 , _ENV["坐标Y"] + 10 , 800 , 1000)
							end
							_ENV["找字信息"] = {
								["文字"] = 转换结果[i].label ,
								["坐标X"] = _ENV["坐标X"] ,
								["坐标Y"] = _ENV["坐标Y"]
							}
							print("耗时:" .. tickCount() - 开始时间 .. "ms")
							return true
						end
					end
				end
				return false
			else
				for i = 1 , #转换结果 do
					for g = 1 , #文字数组 do
						if 转换结果[i].label == 文字数组[g] then
							_ENV["找字信息"] = {
								["文字"] = 转换结果[i].label ,
								["坐标X"] = 转换结果[1].x + x1 ,
								["坐标Y"] = 转换结果[1].y + y1
							}
							print("耗时:" .. tickCount() - 开始时间 .. "ms")
							if 点击 then
								_ENV["鼠标_随机点击"](_ENV["找字信息"]["坐标X"] + 10 , _ENV["找字信息"]["坐标Y"] + 10 , 800 , 1000)
							end
							return true
						end
					end
				end
				return false
			end
		end
		return false
	end
	return false
end
_ENV["文字寻找精准88"] = function(x1 , y1 , x2 , y2 , 类型 , 文字 , 点击)
	local Bitmap = LuaEngine.snapShot(x1 , y1 , x2 , y2)
	local jsonstring = PaddleOcr.detect(Bitmap) ----百度免费版本
	
	if jsonstring ~= "" then
		local 转换结果 = jsonLib.decode(jsonstring)
		if 1 <= #转换结果 then
			local 文字数组 = splitStr(文字 , "|")
			
			for i = 1 , #转换结果 do
				
				for g = 1 , #文字数组 do
					print(转换结果[i].label)
					if 转换结果[i].label == 文字数组[g] then
						_ENV["找字信息"] = {
							["文字"] = 转换结果[i].label ,
							["坐标X"] = 转换结果[1].x + x1 ,
							["坐标Y"] = 转换结果[1].y + y1
						}
						if 点击 then
							_ENV["鼠标_随机点击"](_ENV["找字信息"]["坐标X"] + 10 , _ENV["找字信息"]["坐标Y"] + 10 , 800 , 1000)
						end
						return true
					end
				end
			end
			
		end
		return false
	end
	return false
	
end

